home *** CD-ROM | disk | FTP | other *** search
/ BCI NET 2 / BCI NET 2.iso / archives / programming / gui / precog2_1.lha / Precognition2_1 / src / src.lha / Library / pcgWindow.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-12-16  |  24.0 KB  |  1,014 lines
  1. #include <exec/types.h>
  2. #include <exec/nodes.h>
  3. #include <exec/lists.h>
  4. #include <exec/ports.h>
  5. #include <stdio.h>
  6.  
  7. #include "pcgWindow.h"
  8. #include "pcgWindowClass.h"
  9. #include "Precognition_Utils.h"
  10. #include "minmax.h"
  11. #ifndef __GNUC__
  12. #include <clib/exec_protos.h>
  13. #include <clib/intuition_protos.h>
  14. #include <clib/graphics_protos.h>
  15. #include <clib/layers_protos.h>
  16. #endif
  17. #ifdef __GNUC__
  18. #include <proto/exec.h>
  19. #include <proto/intuition.h>
  20. #include <proto/graphics.h>
  21. #include <proto/layers.h>
  22. #endif
  23. #ifdef __SASC
  24. #include <proto/exec.h>
  25. #include <proto/intuition.h>
  26. #include <proto/graphics.h>
  27. #include <proto/layers.h>
  28. #endif
  29.  
  30. #include "amigamem.h"
  31. /* Additions for Prototypes -- EDB */
  32. #include "Intuition_utils.h"
  33.  
  34. extern struct IntuitionBase *IntuitionBase;
  35.  
  36.  
  37. Screen *pcgWindow_GetScreen( pcgWindow *self )
  38. {
  39.    Screen *screen;
  40.    Window *iwindow;
  41.  
  42.    if( iwindow = iWindow( self ) )
  43.       screen = self->Window->WScreen;
  44.    else
  45.       screen = self->NewWindow.Screen;
  46.  
  47.    return screen;
  48. }
  49.  
  50.  
  51. BOOL pcgWindow_SanityCheck(  pcgWindow *self,
  52.                              Point     *location,
  53.                              Point     *size )
  54.    /* returns TRUE if location was changed. */
  55. {
  56.    Screen *screen;
  57.    BOOL loc_changed = FALSE;
  58.  
  59. /*   printf("SanityCheck before: Location=%d,%d, Size=%d,%d\n",*/
  60. /*      location->x, location->y, size->x, size->y );*/
  61.  
  62.    screen = pcgWindow_GetScreen( self );
  63.  
  64.    if( screen != NULL )
  65.    {
  66.       size->x = MIN( size->x, screen->Width );
  67.       size->y = MIN( size->y, screen->Height );
  68.  
  69.       /* size is now ok, so check location. */
  70.       if( location->x + size->x >= screen->Width )
  71.       {
  72.          location->x = screen->Width - size->x;
  73.          loc_changed = TRUE;
  74.       }
  75.       if( location->y + size->y >= screen->Height )
  76.       {
  77.          location->y = screen->Height - size->y;
  78.          loc_changed = TRUE;
  79.       }
  80.  
  81.    }
  82.  
  83.    return loc_changed;
  84. }
  85.  
  86.  
  87. Point pcgWindow_Location( pcgWindow *self )
  88. {
  89.    Point location;
  90.  
  91.    struct Window *iwindow;
  92.  
  93.    if( iwindow = iWindow( self ) )
  94.    {
  95.       location.x = iwindow->LeftEdge;
  96.       location.y = iwindow->TopEdge;
  97.    }
  98.    else
  99.    {
  100.       location = self->Location;
  101.    }
  102.  
  103.    return location;
  104. }
  105.  
  106.  
  107. Point pcgWindow_Size( pcgWindow *self )
  108. {
  109.    Point size;
  110.  
  111.    struct Window *iwindow;
  112.  
  113.    if( iwindow = iWindow( self ) )
  114.    {
  115.       size.x = iwindow->Width;
  116.       size.y = iwindow->Height;
  117.    }
  118.    else
  119.    {
  120.       size = self->Size;
  121.    }
  122.  
  123.    return size;
  124. }
  125.  
  126.  
  127.  
  128. Point pcgWindow_SetLocation( pcgWindow *self, WORD LeftEdge, WORD TopEdge )
  129. {
  130.    Point location, new_loc, size;
  131.    WORD dx, dy;
  132.    struct Window *iwindow;
  133.  
  134.    location  = Location( (GraphicObject *)self );
  135.    size      = Size( (GraphicObject *)self );
  136.    new_loc.x = LeftEdge;
  137.    new_loc.y = TopEdge;
  138.  
  139.    pcgWindow_SanityCheck( self, &new_loc, &size );
  140.  
  141.    /*printf("pcgWindow_SetLocation\n");*/
  142.    if( iwindow = iWindow( self ) )
  143.    {
  144.  
  145.       dx = new_loc.x - location.x;
  146.       dy = new_loc.y - location.y;
  147.  
  148.       MoveWindow( iwindow, dx, dy );
  149.  
  150.       self->Location.x = self->NewWindow.LeftEdge = iwindow->LeftEdge;
  151.       self->Location.y = self->NewWindow.TopEdge  = iwindow->TopEdge;
  152.    }
  153.    else
  154.    {
  155.       self->Location.x = self->NewWindow.LeftEdge = new_loc.x;
  156.       self->Location.y = self->NewWindow.TopEdge  = new_loc.y;
  157.    }
  158.  
  159.  
  160.    return self->Location;
  161. }
  162.  
  163.  
  164. Point pcgWindow_SetSize( pcgWindow *self, WORD width, WORD height )
  165. {
  166.    Point size, location, new_size;
  167.    WORD dx, dy;
  168.    struct Window *iwindow;
  169.  
  170.    new_size.x = width;
  171.    new_size.y = height;
  172.    location = Location( (GraphicObject *)self );
  173.    if( pcgWindow_SanityCheck( self, &location, &new_size ) )
  174.    {
  175.       /* In order to set this size, you have to first move the window. */
  176.       SetLocation( (GraphicObject *)self, location.x, location.y );
  177.    }
  178.  
  179.    /*printf("pcgWindow_SetSize\n");*/
  180.    if( iwindow = iWindow( self ) )
  181.    {
  182.       /*printf("window is open.\n");*/
  183.  
  184.       size     = Size( (GraphicObject *)self );
  185.       dx = new_size.x - size.x;
  186.       dy = new_size.y - size.y;
  187.       /*printf("size.x,y = (%d,%d), dx,dy=(%d,%d)\n", size.x, size.y, dx, dy );*/
  188.       SizeWindow( iwindow, dx, dy );
  189.       self->NewWindow.Width  = self->Size.x = iwindow->Width;
  190.       self->NewWindow.Height = self->Size.y = iwindow->Height;
  191.    }
  192.    else
  193.    {
  194.       self->Size.x = self->NewWindow.Width  = new_size.x;
  195.       self->Size.y = self->NewWindow.Height = new_size.y;
  196.    }
  197.  
  198.    return self->Size;
  199. }
  200.  
  201.  
  202. struct Window *pcgWindow_OpenWindow( pcgWindow *self )
  203. {
  204.    /*printf("pcgWindow_OpenWindow\n");*/
  205.  
  206.    if( self->Window ) return self->Window;
  207.  
  208.    if( self->SharedUserPort )
  209.       self->Window = OpenWindowWithSharedUserPort(
  210.          &self->NewWindow, self->SharedUserPort );
  211.    else  /* normal open window. */
  212.       self->Window = SmartOpenWindow( &self->NewWindow );
  213.  
  214.    if( self->Window )
  215.    {
  216.       self->Window->UserData = (APTR)self;
  217.  
  218.       if( self->MenuStrip )
  219.          SetMenuStrip( self->Window, self->MenuStrip );
  220.    }
  221.    return self->Window;
  222. }
  223.  
  224.  
  225.  
  226. void pcgWindow_CloseWindow( pcgWindow *self )
  227. {
  228.    Window *w;
  229.    Point size, loc;
  230.  
  231.    if( w = self->Window )
  232.    {
  233.       /* Record size and location (for possible reopen). */
  234.       loc  = Location( (GraphicObject *)self );
  235.       size = Size( (GraphicObject *)self );
  236.  
  237.       if( w->MenuStrip ) ClearMenuStrip( w );
  238.  
  239.       if( self->SharedUserPort )
  240.       {
  241.          /* Cannot simply close a SharedUserPort window, because
  242.           * Intution will deallocate the UserPort, and some other
  243.           * applications may be using them.  (Instant GURU)
  244.           */
  245.          CloseWindowWithSharedUserPort( w );
  246.       }
  247.       else
  248.          CloseWindow( w );
  249.  
  250.       self->Window = NULL;
  251.  
  252.       SetSize( (GraphicObject *)self, size.x, size.y );
  253.       SetLocation( (GraphicObject *)self, loc.x, loc.y );
  254.    }
  255. }
  256.  
  257. pcgWindow *pcgWindow_InteractorWindow( pcgWindow *self ) { return self; }
  258.  
  259.  
  260. Gadget *pcgWindow_FirstGadget( pcgWindow *self )
  261. {
  262.    Gadget *g;
  263.    struct Window *iwindow;
  264.  
  265.    if( iwindow = iWindow( self ) )
  266.    {
  267.       g = iwindow->FirstGadget;
  268.    }
  269.    else
  270.    {
  271.       g = self->NewWindow.FirstGadget;
  272.    }
  273.    return g;
  274. }
  275.  
  276.  
  277. USHORT pcgWindow_nGadgets( pcgWindow *self )
  278. {
  279.    Gadget *g;
  280.    USHORT count = 0;
  281.  
  282.    for( g = FirstGadget( (Interactor *)self ); g != NULL; g = g->NextGadget )
  283.       count++;
  284.  
  285.    return count;
  286. }
  287.  
  288.  
  289. ULONG pcgWindow_IDCMPFlags( pcgWindow *self )
  290. {
  291.    struct Window *iwindow;
  292.  
  293.    if( iwindow = iWindow( self ) )
  294.       return iwindow->IDCMPFlags;
  295.    else
  296.       return self->NewWindow.IDCMPFlags;
  297. }
  298.  
  299.  
  300. USHORT pcgWindow_ClaimEvent( pcgWindow *self, IntuiMessage *event )
  301. {
  302.    struct Window *iwindow;
  303.    USHORT response = 0;
  304.    Interactor *iactor;
  305.  
  306.    if( iwindow = iWindow( self ) )
  307.    {
  308.       if( event->IDCMPWindow = iwindow )
  309.       {
  310.          response = RESPONDED;
  311.  
  312.          for( iactor = self->FirstInteractor; iactor != NULL; iactor = iactor->Next )
  313.          {
  314.             response |= ClaimEvent( iactor, event );
  315.             if( response & CONSUMED_EVENT )
  316.                break;
  317.          }
  318.       }
  319.    }
  320.    return response;
  321. }
  322.  
  323.  
  324. void pcgWindow_AddGraphicObject( pcgWindow      *window,
  325.                                  GraphicObject   *graphic )
  326. {
  327.    GraphicObject *g;
  328.  
  329.    if( window->FirstGraphic )
  330.    {
  331.       for( g = window->FirstGraphic;
  332.            g->Next != NULL;
  333.            g = g->Next );
  334.  
  335.       g->Next = graphic;
  336.    }
  337.    else
  338.       window->FirstGraphic = graphic;
  339. }
  340.  
  341. void pcgWindow_RemoveGraphicObject( pcgWindow      *window,
  342.                                     GraphicObject  *graphic )
  343. {
  344.    GraphicObject *g;
  345.  
  346.    if( window->FirstGraphic )
  347.    {
  348.       if( window->FirstGraphic == graphic )
  349.       {
  350.          window->FirstGraphic = graphic->Next;
  351.       }
  352.       else
  353.       {
  354.          for(  g  = window->FirstGraphic;
  355.                g != NULL;
  356.                g  = g->Next )
  357.          {
  358.             if( g->Next == graphic )
  359.             {
  360.                g->Next = graphic->Next;
  361.                break;
  362.             }
  363.          }
  364.       }
  365.    }
  366.    graphic->Next = NULL;
  367. }
  368.  
  369.  
  370. void pcgWindow_AddInteractor( pcgWindow  *window,
  371.                               Interactor   *interactor )
  372. {
  373.    Interactor    *iactor;
  374.    ULONG          flags;
  375.    struct Window *iwindow;
  376.  
  377.    SetInteractorWindow( interactor, window );
  378.  
  379.    if( nGadgets( interactor ) ) /* Interactor has gadget(s) */
  380.    {
  381.       if( iwindow = iWindow( window ) )
  382.       {
  383.          AddGList( iwindow, FirstGadget( interactor ),
  384.             (USHORT) ~0, nGadgets( interactor ), NULL );
  385.       }
  386.       else
  387.       {
  388.          /* Add Gadgets to last gadget of window. */
  389.          if( window->NewWindow.FirstGadget )
  390.          {
  391.             ChainGadgets( window->NewWindow.FirstGadget,
  392.                           FirstGadget( interactor ) );
  393.          }
  394.          else
  395.             window->NewWindow.FirstGadget = FirstGadget( interactor );
  396.  
  397.       }
  398.    }
  399.  
  400.    /* add this interactor to chain of interactors. */
  401.    if( window->FirstInteractor )
  402.    {
  403.       for( iactor = window->FirstInteractor;
  404.            iactor->Next != NULL;
  405.            iactor = iactor->Next );
  406.  
  407.       iactor->Next = interactor;
  408.    }
  409.    else
  410.       window->FirstInteractor = interactor;
  411.  
  412.    /* Add IDCMP flags */
  413.  
  414.    flags = IDCMPFlags( (Interactor *)window ) | IDCMPFlags( interactor );
  415.    SetIDCMPFlags( window, flags );
  416.  
  417.    /*printf( "AddIActor: %s IDCMPFlags=%d\n",*/
  418.    /*   PClassName( interactor ), IDCMPFlags(interactor) );*/
  419. }
  420.  
  421.  
  422. ULONG pcgWindow_SetIDCMPFlags( pcgWindow *self, ULONG newflags )
  423. {
  424.    struct Window *iwindow;
  425.    self->NewWindow.IDCMPFlags = newflags;
  426.  
  427.    /*printf( "SetIDCMPFlags: %d\n", newflags );*/
  428.    if( iwindow = iWindow( self ) ) /* window is open */
  429.    {
  430.       ModifyIDCMP( iwindow, newflags );
  431.    }
  432.  
  433.    return IDCMPFlags( (Interactor *)self );
  434. }
  435.  
  436.  
  437.  
  438. struct RastPort *pcgWindow_RPort( pcgWindow *self )
  439. {
  440.    if( self->Window )
  441.       return self->Window->RPort;
  442.    return NULL;
  443. }
  444.  
  445.  
  446.  
  447. void pcgWindow_Refresh( pcgWindow *window )
  448. {
  449.    GraphicObject     *graphic;
  450.    Interactor        *interactor;
  451.    RastPort          *rport;
  452.    struct Window     *iwindow;
  453.  
  454.    if( iwindow = iWindow( window ) )
  455.    {
  456.       rport = RPort( window );
  457.  
  458.     /* Removed RefreshWindowBorder(); call
  459.      * -- caused lock-ups sometimes,
  460.      * when user rapidly resizes window
  461.      * -- EDB */
  462.  
  463.     /* This may not be necessary -- EDB */
  464.     /* Lock the Window's layer so its size will not change during refresh */
  465.        LockLayer( NULL, iwindow->WLayer );
  466.  
  467.     /* do our work while window's layer is locked */
  468.  
  469.       /* Draw window graphics */
  470.       for( graphic = window->FirstGraphic;
  471.            graphic != NULL;
  472.            graphic = graphic->Next )
  473.       {
  474.          Render( graphic, rport );
  475.       }
  476.  
  477.       /* Draw interactors */
  478.       for ( interactor  = window->FirstInteractor;
  479.             interactor != NULL;
  480.             interactor  = interactor->Next )
  481.       {
  482.          Refresh( interactor );
  483.       }
  484.  
  485.       /* Unlock the Window's layer so normal operations can resume */
  486.       UnlockLayer( iwindow->WLayer );
  487.  
  488.  
  489.    }
  490. }
  491.  
  492.  
  493. BOOL pcgWindow_Activate( pcgWindow *self, BOOL activate )
  494. {
  495.    struct Window *iwindow;
  496.  
  497.    if( iwindow = iWindow( self ) )
  498.    {
  499.       if( activate )
  500.       {
  501.          ActivateWindow( iwindow );
  502.       }
  503.    }
  504.    return isActive( (Interactor *)self );
  505. }
  506.  
  507.  
  508.  
  509. #define DONT_CHANGE_SCREEN_TITLE ((char*)-1)
  510.  
  511. BOOL pcgWindow_SetTitle( pcgWindow *self,
  512.                          char      *title )
  513. {
  514.    struct Window *iwindow;
  515.    char *t;
  516.  
  517.    Afree( Title( (GraphicObject *)self ) );
  518.    t = Astrdup( title );
  519.  
  520.    if( iwindow = iWindow( self ) )
  521.    {
  522.       SetWindowTitles( iwindow, t, DONT_CHANGE_SCREEN_TITLE );
  523.    }
  524.  
  525.    self->NewWindow.Title = t;
  526.    return TRUE;
  527. }
  528.  
  529. char *pcgWindow_Title( pcgWindow *self )
  530. {
  531.    return (char *)self->NewWindow.Title;
  532. }
  533.  
  534. struct Window *pcgWindow_iWindow( pcgWindow *self )
  535. {
  536.    return self->Window;
  537. }
  538.  
  539.  
  540. struct Window *pcgOpenWindow( pcgWindow *self )
  541. {
  542.    struct pcgWindowClass *class;
  543.    struct Window *result = NULL;
  544.  
  545.    /*printf( "pcgOpenWindow\n" );*/
  546.  
  547.    if( class = (struct pcgWindowClass *)self->isa )
  548.    {
  549.       if( class->OpenWindow )
  550.          result = (*class->OpenWindow)( self );
  551.    }
  552.  
  553.    if( result )
  554.       Refresh( (Interactor *)self );
  555.  
  556.    return result;
  557. }
  558.  
  559.  
  560. void pcgCloseWindow( pcgWindow *self )
  561. {
  562.    struct pcgWindowClass *class;
  563.  
  564.    if( class = (struct pcgWindowClass *)self->isa )
  565.    {
  566.       if( class->CloseWindow )
  567.          (*class->CloseWindow)( self );
  568.    }
  569. }
  570.  
  571.  
  572. struct Window *iWindow( pcgWindow *self )
  573. {
  574.    struct pcgWindowClass *class;
  575.    struct Window *result = NULL;
  576.  
  577.    if( class = (struct pcgWindowClass *)self->isa )
  578.    {
  579.       if( class->iWindow )
  580.          result = (*class->iWindow)( self );
  581.    }
  582.    return result;
  583. }
  584.  
  585. RastPort *RPort( pcgWindow *self )
  586. {
  587.    struct pcgWindowClass *class;
  588.    struct RastPort *result = NULL;
  589.  
  590.    if( class = (struct pcgWindowClass *)self->isa )
  591.    {
  592.       if( class->RPort )
  593.          result = (*class->RPort)( self );
  594.    }
  595.    return result;
  596. }
  597.  
  598.  
  599. ULONG SetIDCMPFlags( pcgWindow *self, ULONG flags )
  600. {
  601.    struct pcgWindowClass *class;
  602.  
  603.    if( class = (struct pcgWindowClass *)self->isa )
  604.    {
  605.       if( class->SetIDCMPFlags )
  606.          flags = (*class->SetIDCMPFlags)( self, flags );
  607.    }
  608.    return flags;
  609. }
  610.  
  611.  
  612. void AddGraphicObject( pcgWindow *self, GraphicObject *graphic )
  613. {
  614.    struct pcgWindowClass *class;
  615.  
  616.    if( class = (struct pcgWindowClass *)self->isa )
  617.    {
  618.       if( class->AddGraphicObject )
  619.          (*class->AddGraphicObject)( self, graphic );
  620.    }
  621. }
  622.  
  623. void RemoveGraphicObject( pcgWindow *self, GraphicObject *graphic )
  624. {
  625.    struct pcgWindowClass *class;
  626.  
  627.    if( class = (struct pcgWindowClass *)self->isa )
  628.    {
  629.       if( class->RemoveGraphicObject )
  630.          (*class->RemoveGraphicObject)( self, graphic );
  631.    }
  632. }
  633.  
  634. void AddInteractor( pcgWindow *self, Interactor *interactor )
  635. {
  636.    struct pcgWindowClass *class;
  637.  
  638.    if( class = (struct pcgWindowClass *)self->isa )
  639.    {
  640.       if( class->AddInteractor )
  641.          (*class->AddInteractor)( self, interactor );
  642.    }
  643. }
  644.  
  645. void RemoveInteractor( pcgWindow *self, Interactor *interactor )
  646. {
  647.    struct pcgWindowClass *class;
  648.  
  649.    if( class = (struct pcgWindowClass *)self->isa )
  650.    {
  651.       if( class->RemoveInteractor )
  652.          (*class->RemoveInteractor)( self, interactor );
  653.    }
  654. }
  655.  
  656. void AddWindowPObject( pcgWindow *window, GraphicObject *obj )
  657. {
  658.    if( isa( (PObject *)obj, InteractorClass() ) )
  659.       AddInteractor( window, (Interactor*) obj );
  660.    else
  661.       AddGraphicObject( window, obj );
  662. }
  663.  
  664. void RemoveWindowPObject( pcgWindow *window, GraphicObject *obj )
  665. {
  666.    if( isa( (PObject *)obj, InteractorClass() ) )
  667.       RemoveInteractor( window, (Interactor*) obj );
  668.    else
  669.       RemoveGraphicObject( window, obj );
  670. }
  671.  
  672.  
  673.  
  674. void AddMenuStrip( pcgWindow *self, Menu *menustrip )
  675. {
  676.    struct pcgWindowClass *class;
  677.  
  678.    if( class = (struct pcgWindowClass *)self->isa )
  679.    {
  680.       if( class->AddMenuStrip )
  681.          (*class->AddMenuStrip)( self, menustrip );
  682.    }
  683. }
  684.  
  685. void RemoveMenuStrip( pcgWindow *self )
  686. {
  687.    struct pcgWindowClass *class;
  688.  
  689.    if( class = (struct pcgWindowClass *)self->isa )
  690.    {
  691.       if( class->RemoveMenuStrip )
  692.          (*class->RemoveMenuStrip)( self );
  693.    }
  694. }
  695.  
  696. void pcgWindow_RemoveIactorGadgets( pcgWindow *self,
  697.                                     Interactor *interactor )
  698. {
  699.    Gadget        *gadget, *prev_gadget, *next_gadget, *last_gadget;
  700.    USHORT         i, ngadgets;
  701.    struct Window *iwindow;
  702.  
  703.    if( gadget = FirstGadget( interactor ) )
  704.    {
  705.       ngadgets = nGadgets( interactor );
  706.       if( iwindow = iWindow( self ) ) /* window is open. */
  707.       {
  708.          RemoveGList( iwindow, gadget, ngadgets );
  709.       }
  710.       else /* window is not open. */
  711.       {
  712.          next_gadget = gadget;
  713.  
  714.          for( i = 0; i < ngadgets; i++ )
  715.          {
  716.             last_gadget = next_gadget;
  717.             next_gadget = next_gadget->NextGadget;
  718.          }
  719.          last_gadget->NextGadget = NULL;
  720.  
  721.          if( self->NewWindow.FirstGadget == gadget )
  722.          {
  723.             self->NewWindow.FirstGadget = next_gadget;
  724.          }
  725.          else
  726.          {
  727.             for( prev_gadget  = self->NewWindow.FirstGadget;
  728.                  prev_gadget != NULL;
  729.                  prev_gadget  = prev_gadget->NextGadget )
  730.             {
  731.                if( prev_gadget->NextGadget == gadget )
  732.                {
  733.                   prev_gadget->NextGadget = next_gadget;
  734.                   break;
  735.                }
  736.             }
  737.          }
  738.       }
  739.    }
  740.  
  741. }
  742.  
  743. void pcgWindow_RemoveInteractor( pcgWindow  *self,
  744.                                  Interactor *interactor )
  745. {
  746.    Interactor    *iactor;
  747.    ULONG          flags = 0;
  748.  
  749.    SetInteractorWindow( interactor, NULL );
  750.  
  751.    if( self->FirstInteractor )
  752.    {
  753.       if( self->FirstInteractor == interactor )
  754.          self->FirstInteractor = interactor->Next;
  755.       else
  756.       {
  757.          for(  iactor  = self->FirstInteractor;
  758.                iactor != NULL;
  759.                iactor  = iactor->Next )
  760.          {
  761.             if( iactor->Next == interactor )
  762.             {
  763.                iactor->Next = interactor->Next;
  764.                pcgWindow_RemoveIactorGadgets( self, interactor );
  765.                break;
  766.             }
  767.          }
  768.       }
  769.       interactor->Next = NULL;
  770.  
  771.    }
  772.  
  773.  
  774.    /* Compute needed IDCMP flags w/o this responder.        */
  775.    flags = self->IDCMPFlags;
  776.    for(  iactor  = self->FirstInteractor;
  777.          iactor != NULL;
  778.          iactor  = iactor->Next )
  779.       flags |= IDCMPFlags( iactor );
  780.  
  781.    SetIDCMPFlags( self, flags );
  782. }
  783.  
  784. BOOL pcgWindow_EnableIactor( pcgWindow *self, BOOL enable )
  785. {
  786.    Window      *iwindow;
  787.    Interactor  *iactor;
  788.    Gadget      *gadget;
  789.    Menu        *menu;
  790.    UWORD        mcount;
  791.  
  792.    if( iwindow = self->Window )
  793.    {
  794.       iactor = self->FirstInteractor;
  795.       gadget = ( iactor ) ? FirstGadget( iactor ) : NULL;
  796.  
  797.       if( enable )
  798.       {
  799.          if( gadget )
  800.             AddGList( iwindow, gadget, nGadgets( (Interactor *)self ), -1, NULL );
  801.  
  802.          SetIDCMPFlags( self, self->NewWindow.IDCMPFlags );
  803.          /* enable menus. */
  804.          for( menu  = iwindow->MenuStrip, mcount=0;
  805.               menu != NULL;
  806.               menu  = menu->NextMenu, mcount++ )
  807.             OnMenu( iwindow, mcount | (NOITEM<<5) );
  808.  
  809.         ClearPointer( iwindow );
  810.  
  811.       }
  812.       else /* disable it. */
  813.       {
  814.          if( gadget )
  815.             RemoveGList( iwindow, gadget, -1 );
  816.  
  817.          if( self->SharedUserPort )
  818.          {
  819.             /* Can't set IDCMPport to NULL if its shared. */
  820.             ModifyIDCMP( iwindow, REFRESHWINDOW );
  821.          }
  822.          else
  823.          {
  824.             ModifyIDCMP( iwindow, 0 );
  825.          }
  826.  
  827.          SetWaitPointer( iwindow );
  828.  
  829.          /* disable menus. */
  830.          for( menu  = iwindow->MenuStrip, mcount=0;
  831.               menu != NULL;
  832.               menu  = menu->NextMenu, mcount++ )
  833.             OffMenu( iwindow, mcount | ( NOITEM << 5 ) );
  834.  
  835.       }
  836.    }
  837.    else return FALSE;
  838. }
  839.  
  840.  
  841. void pcgWindow_AddMenuStrip( pcgWindow *window, Menu *menustrip )
  842. {
  843.    if( window->MenuStrip ) /* window already has a menu */
  844.    {
  845.       RemoveMenuStrip( window );
  846.    }
  847.  
  848.    window->MenuStrip = menustrip;
  849.    if( window->Window ) /* Window is open */
  850.    {
  851.       SetMenuStrip( window->Window, menustrip );
  852.    }
  853. }
  854.  
  855.  
  856. void pcgWindow_RemoveMenuStrip( pcgWindow *window )
  857. {
  858.    window->MenuStrip = NULL;
  859.    if( window->Window ) /* its open. */
  860.    {
  861.       ClearMenuStrip( window->Window );
  862.    }
  863. }
  864.  
  865. void pcgWindow_Erase( pcgWindow *self )
  866. {
  867.    Window    *window;
  868.    RastPort  *rport;
  869.  
  870.    window = iWindow( self );
  871.    rport  = RPort( self );
  872.  
  873.    SetDrMd ( rport, JAM2 );
  874.    SetAPen ( rport, 0 );
  875.    RectFill( rport, 0,0, window->Width, window->Height );
  876. }
  877.  
  878.  
  879.  
  880. void pcgWindow_Render( pcgWindow *self, RastPort *dontcare )
  881. {
  882.    pcgWindow_Erase( self );
  883.    Refresh ( (Interactor *)self );
  884. }
  885.  
  886. BOOL pcgWindow_elaborated = FALSE;
  887.  
  888. struct pcgWindowClass pcgWindow_Class;
  889.  
  890. void pcgWindow_CleanUp( pcgWindow *self )
  891. {
  892.    pcgCloseWindow( self );
  893. }
  894.  
  895.  
  896. void pcgWindowClass_Init( struct pcgWindowClass *class )
  897. {
  898.    InteractorClass_Init( (struct InteractorClass *) class );
  899.    class->isa                 = InteractorClass();
  900.    class->ClassName           = "pcgWindow";
  901.    class->CleanUp             = (void(*)(PObject *))pcgWindow_CleanUp;
  902.  
  903.    class->Location            = (Point(*)(GraphicObject *))pcgWindow_Location;
  904.    class->SetLocation         = (Point(*)(GraphicObject *, PIXELS, PIXELS))pcgWindow_SetLocation;
  905.    class->Size                = (Point(*)(GraphicObject *))pcgWindow_Size;
  906.    class->AskSize             = NULL;
  907.    class->SetSize             = (Point(*)(GraphicObject *, PIXELS, PIXELS))pcgWindow_SetSize;
  908.    /*class->SizeFlags           = GraphicObject_SizeFlagsAll;*/
  909.    class->Render              = (void(*)(GraphicObject *, RastPort *))pcgWindow_Render;
  910.    class->InteractorWindow    = (struct pcgWindow*(*)(Interactor *))pcgWindow_InteractorWindow;
  911.    class->SetInteractorWindow = NULL;
  912.    class->FirstGadget         = (Gadget*(*)(Interactor *))pcgWindow_FirstGadget;
  913.    class->nGadgets            = (USHORT(*)(Interactor *))pcgWindow_nGadgets;
  914.    class->IDCMPFlags          = (ULONG(*)(Interactor *))pcgWindow_IDCMPFlags;
  915.    class->ClaimEvent          = (USHORT(*)(Interactor *, IntuiMessage *))pcgWindow_ClaimEvent;
  916.    class->Respond             = NULL;
  917.    class->Refresh             = (void(*)(Interactor *))pcgWindow_Refresh;
  918.    class->EnableIactor              = (BOOL(*)(Interactor *, BOOL))pcgWindow_EnableIactor;
  919. /*   class->isEnabled           = pcgWindow_isEnabled;*/
  920.    class->Activate            = (BOOL(*)(Interactor *, BOOL))pcgWindow_Activate;
  921.    class->isActive            = NULL; /* pcgWindow_isActive;*/
  922.    class->SetTitle            = (BOOL(*)(GraphicObject *, char *))pcgWindow_SetTitle;
  923.    class->Title               = (char*(*)(GraphicObject *))pcgWindow_Title;
  924.  
  925.    class->OpenWindow          = pcgWindow_OpenWindow;
  926.    class->CloseWindow         = pcgWindow_CloseWindow;
  927.    class->iWindow             = pcgWindow_iWindow;
  928.    class->RPort               = pcgWindow_RPort;
  929.    class->SetIDCMPFlags       = pcgWindow_SetIDCMPFlags;
  930.    class->AddGraphicObject    = pcgWindow_AddGraphicObject;
  931.    class->RemoveGraphicObject = pcgWindow_RemoveGraphicObject;
  932.    class->AddInteractor       = pcgWindow_AddInteractor;
  933.    class->RemoveInteractor    = pcgWindow_RemoveInteractor;
  934.    class->AddMenuStrip        = pcgWindow_AddMenuStrip;
  935.    class->RemoveMenuStrip     = pcgWindow_RemoveMenuStrip;
  936. }
  937.  
  938.  
  939. struct pcgWindowClass *pcgWindowClass( void )
  940. {
  941.    if( ! pcgWindow_elaborated )
  942.    {
  943.       pcgWindowClass_Init( &pcgWindow_Class );
  944.       pcgWindow_elaborated = TRUE;
  945.    }
  946.  
  947.    return &pcgWindow_Class;
  948. }
  949.  
  950.  
  951.  
  952. void pcgWindow_Init( pcgWindow     *self,
  953.                      UWORD          leftedge,
  954.                      UWORD          topedge,
  955.                      UWORD          width,
  956.                      UWORD          height,
  957.                      UWORD          minwidth,
  958.                      UWORD          minheight,
  959.                      UWORD          maxwidth,
  960.                      UWORD          maxheight,
  961.                      char          *title,
  962.                      ULONG          IDCMPFlags,
  963.                      ULONG          flags,
  964.                      struct Screen *screen )
  965. {
  966.  
  967.    Interactor_Init( (Interactor *)self );
  968.  
  969.    self->isa                     = pcgWindowClass();
  970.    self->Window                  = NULL;
  971.    self->FirstInteractor         = NULL;
  972.    self->FirstGraphic            = NULL;
  973.    self->SharedUserPort          = NULL;
  974.    self->MenuStrip               = NULL;
  975.  
  976.    self->NewWindow.BlockPen      = 1;
  977.    self->NewWindow.DetailPen     = 0;
  978.    self->NewWindow.IDCMPFlags    = self->IDCMPFlags = IDCMPFlags;
  979.    self->NewWindow.Flags         = flags;
  980.    self->NewWindow.FirstGadget   = NULL;
  981.    self->NewWindow.CheckMark     = NULL;
  982.    self->NewWindow.Title         = NULL;
  983.    self->NewWindow.BitMap        = NULL;
  984.    self->NewWindow.MinWidth      = minwidth;
  985.    self->NewWindow.MinHeight     = minheight;
  986.    self->NewWindow.MaxWidth      = maxwidth;
  987.    self->NewWindow.MaxHeight     = maxheight;
  988.    if( screen )
  989.    {
  990.       self->NewWindow.Type = CUSTOMSCREEN;
  991.       self->NewWindow.Screen = screen;
  992.    }
  993.    else
  994.    {
  995.       self->NewWindow.Type   = WBENCHSCREEN;
  996.       self->NewWindow.Screen = NULL;
  997.    }
  998.  
  999.    /*
  1000.    ** Have to have an initial size before you can call
  1001.    ** SetSize or SetLocation
  1002.    */
  1003.    self->Location.x = self->NewWindow.LeftEdge = 0;
  1004.    self->Location.y = self->NewWindow.TopEdge  = 0;
  1005.    self->Size.x     = self->NewWindow.Width    = 0;
  1006.    self->Size.y     = self->NewWindow.Height   = 0;
  1007.  
  1008.    SetSize( (GraphicObject *)self, width, height );
  1009.    SetLocation( (GraphicObject *)self, leftedge, topedge );
  1010.    SetTitle( (GraphicObject *)self, title );
  1011. }
  1012.  
  1013.  
  1014.